home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 15 / CU Amiga Magazine's Super CD-ROM 15 (1997)(EMAP Images)(GB)[!][issue 1997-10].iso / CUCD / Graphics / Ghostscript / source / gdevm24.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-06-13  |  13.2 KB  |  491 lines
  1. /* Copyright (C) 1994, 1995, 1996, 1997 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of Aladdin Ghostscript.
  4.   
  5.   Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6.   or distributor accepts any responsibility for the consequences of using it,
  7.   or for whether it serves any particular purpose or works at all, unless he
  8.   or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9.   License (the "License") for full details.
  10.   
  11.   Every copy of Aladdin Ghostscript must include a copy of the License,
  12.   normally in a plain ASCII text file named PUBLIC.  The License grants you
  13.   the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14.   under certain conditions described in the License.  Among other things, the
  15.   License requires that the copyright notice and this notice be preserved on
  16.   all copies.
  17. */
  18.  
  19. /* gdevm24.c */
  20. /* 24-bit-per-pixel "memory" (stored bitmap) device */
  21. #include "memory_.h"
  22. #include "gx.h"
  23. #include "gxdevice.h"
  24. #include "gxdevmem.h"            /* semi-public definitions */
  25. #include "gdevmem.h"            /* private definitions */
  26.  
  27. extern dev_proc_strip_copy_rop(mem_gray8_rgb24_strip_copy_rop);  /* in gdevmrop.c */
  28. #define mem_true24_strip_copy_rop mem_gray8_rgb24_strip_copy_rop
  29.  
  30. /* ================ Standard (byte-oriented) device ================ */
  31.  
  32. #undef chunk
  33. #define chunk byte
  34.  
  35. /* Procedures */
  36. declare_mem_procs(mem_true24_copy_mono, mem_true24_copy_color, mem_true24_fill_rectangle);
  37. private dev_proc_copy_alpha(mem_true24_copy_alpha);
  38.  
  39. /* The device descriptor. */
  40. const gx_device_memory far_data mem_true24_device =
  41.   mem_full_alpha_device("image24", 24, 0, mem_open,
  42.     gx_default_rgb_map_rgb_color, gx_default_rgb_map_color_rgb,
  43.     mem_true24_copy_mono, mem_true24_copy_color, mem_true24_fill_rectangle,
  44.     mem_get_bits, gx_default_map_cmyk_color, mem_true24_copy_alpha,
  45.     gx_default_strip_tile_rectangle, mem_true24_strip_copy_rop);
  46.  
  47. /* Convert x coordinate to byte offset in scan line. */
  48. #undef x_to_byte
  49. #define x_to_byte(x) ((x) * 3)
  50.  
  51. /* Unpack a color into its bytes. */
  52. #define declare_unpack_color(r, g, b, color)\
  53.     byte r = (byte)(color >> 16);\
  54.     byte g = (byte)((uint)color >> 8);\
  55.     byte b = (byte)color
  56. /* Put a 24-bit color into the bitmap. */
  57. #define put3(ptr, r, g, b)\
  58.     (ptr)[0] = r, (ptr)[1] = g, (ptr)[2] = b
  59. /* Put 4 bytes of color into the bitmap. */
  60. #define putw(ptr, wxyz)\
  61.     *(bits32 *)(ptr) = (wxyz)
  62. /* Load the 3-word 24-bit-color cache. */
  63. /* Free variables: [m]dev, rgbr, gbrg, brgb. */
  64. #if arch_is_big_endian
  65. #  define set_color24_cache(crgb, r, g, b)\
  66.     mdev->color24.rgbr = rgbr = ((bits32)(crgb) << 8) | (r),\
  67.     mdev->color24.gbrg = gbrg = (rgbr << 8) | (g),\
  68.     mdev->color24.brgb = brgb = (gbrg << 8) | (b),\
  69.     mdev->color24.rgb = (crgb)
  70. #else
  71. #  define set_color24_cache(crgb, r, g, b)\
  72.     mdev->color24.rgbr = rgbr =\
  73.         ((bits32)(r) << 24) | ((bits32)(b) << 16) |\
  74.         ((bits16)(g) << 8) | (r),\
  75.     mdev->color24.brgb = brgb = (rgbr << 8) | (b),\
  76.     mdev->color24.gbrg = gbrg = (brgb << 8) | (g),\
  77.     mdev->color24.rgb = (crgb)
  78. #endif
  79.  
  80. /* Fill a rectangle with a color. */
  81. private int
  82. mem_true24_fill_rectangle(gx_device *dev,
  83.   int x, int y, int w, int h, gx_color_index color)
  84. {    declare_unpack_color(r, g, b, color);
  85.     declare_scan_ptr(dest);
  86.  
  87.     /*
  88.      * In order to avoid testing w > 0 and h > 0 twice, we defer
  89.      * executing setup_rect, and use fit_fill_xywh instead of
  90.      * fit_fill.
  91.      */
  92.     fit_fill_xywh(dev, x, y, w, h);
  93.     if ( w >= 5 )
  94.       { if ( h <= 0 )
  95.           return 0;
  96.         setup_rect(dest);
  97.         if ( r == g && r == b)
  98.           {
  99. #if 1
  100.         /* We think we can do better than the library's memset.... */
  101.         int bcntm7 = w * 3 - 7;
  102.         register bits32 cword = color | (color << 24);
  103.         while ( h-- > 0 )
  104.         {    register byte *pptr = dest;
  105.             byte *limit = pptr + bcntm7;
  106.             /* We want to store full words, but we have to */
  107.             /* guarantee that they are word-aligned. */
  108.             switch ( x & 3 )
  109.               {
  110.               case 3: *pptr++ = (byte)cword;
  111.               case 2: *pptr++ = (byte)cword;
  112.               case 1: *pptr++ = (byte)cword;
  113.               case 0: ;
  114.               }
  115.             /* Even with w = 5, we always store at least */
  116.             /* 3 full words, regardless of the starting x. */
  117.             *(bits32 *)pptr =
  118.               ((bits32 *)pptr)[1] =
  119.               ((bits32 *)pptr)[2] = cword;
  120.             pptr += 12;
  121.             while ( pptr < limit )
  122.               { *(bits32 *)pptr =
  123.                   ((bits32 *)pptr)[1] = cword;
  124.                 pptr += 8;
  125.               }
  126.             switch ( pptr - limit )
  127.               {
  128.               case 0: pptr[6] = (byte)cword;
  129.               case 1: pptr[5] = (byte)cword;
  130.               case 2: pptr[4] = (byte)cword;
  131.               case 3: *(bits32 *)pptr = cword;
  132.                 break;
  133.               case 4: pptr[2] = (byte)cword;
  134.               case 5: pptr[1] = (byte)cword;
  135.               case 6: pptr[0] = (byte)cword;
  136.               case 7: ;
  137.               }
  138.             inc_ptr(dest, draster);
  139.         }
  140. #else
  141.         int bcnt = w * 3;
  142.         while ( h-- > 0 )
  143.         {    memset(dest, r, bcnt);
  144.             inc_ptr(dest, draster);
  145.         }
  146. #endif
  147.           }
  148.         else
  149.           {    int x3 = -x & 3, ww = w - x3;    /* we know ww >= 2 */
  150.         bits32 rgbr, gbrg, brgb;
  151.         if ( mdev->color24.rgb == color )
  152.           rgbr = mdev->color24.rgbr,
  153.           gbrg = mdev->color24.gbrg,
  154.           brgb = mdev->color24.brgb;
  155.         else
  156.           set_color24_cache(color, r, g, b);
  157.         while ( h-- > 0 )
  158.           {    register byte *pptr = dest;
  159.             int w1 = ww;
  160.             switch ( x3 )
  161.               {
  162.               case 1:
  163.                 put3(pptr, r, g, b);
  164.                 pptr += 3; break;
  165.               case 2:
  166.                 pptr[0] = r; pptr[1] = g;
  167.                 putw(pptr + 2, brgb);
  168.                 pptr += 6; break;
  169.               case 3:
  170.                 pptr[0] = r;
  171.                 putw(pptr + 1, gbrg);
  172.                 putw(pptr + 5, brgb);
  173.                 pptr += 9; break;
  174.               case 0:
  175.                 ;
  176.               }
  177.             while ( w1 >= 4 )
  178.               {    putw(pptr, rgbr);
  179.                 putw(pptr + 4, gbrg);
  180.                 putw(pptr + 8, brgb);
  181.                 pptr += 12;
  182.                 w1 -= 4;
  183.               }
  184.             switch ( w1 )
  185.               {
  186.               case 1:
  187.                 put3(pptr, r, g, b);
  188.                 break;
  189.               case 2:
  190.                 putw(pptr, rgbr);
  191.                 pptr[4] = g; pptr[5] = b;
  192.                 break;
  193.               case 3:
  194.                 putw(pptr, rgbr);
  195.                 putw(pptr + 4, gbrg);
  196.                 pptr[8] = b;
  197.                 break;
  198.               case 0:
  199.                 ;
  200.               }
  201.             inc_ptr(dest, draster);
  202.           }
  203.           }
  204.       }
  205.     else if ( h > 0 )        /* w < 5 */
  206.       {
  207.       setup_rect(dest);
  208.       switch ( w )
  209.         {
  210.         case 4:
  211.         do
  212.           { dest[9] = dest[6] = dest[3] = dest[0] = r;
  213.             dest[10] = dest[7] = dest[4] = dest[1] = g;
  214.             dest[11] = dest[8] = dest[5] = dest[2] = b;
  215.             inc_ptr(dest, draster);
  216.           }
  217.         while ( --h );
  218.         break;
  219.         case 3:
  220.         do
  221.           { dest[6] = dest[3] = dest[0] = r;
  222.             dest[7] = dest[4] = dest[1] = g;
  223.             dest[8] = dest[5] = dest[2] = b;
  224.             inc_ptr(dest, draster);
  225.           }
  226.         while ( --h );
  227.         break;
  228.         case 2:
  229.         do
  230.           { dest[3] = dest[0] = r;
  231.             dest[4] = dest[1] = g;
  232.             dest[5] = dest[2] = b;
  233.             inc_ptr(dest, draster);
  234.           }
  235.         while ( --h );
  236.         break;
  237.         case 1:
  238.         do
  239.           { dest[0] = r, dest[1] = g, dest[2] = b;
  240.             inc_ptr(dest, draster);
  241.           }
  242.         while ( --h );
  243.         break;
  244.         case 0:
  245.         default:
  246.           ;
  247.         }
  248.       }
  249.     return 0;
  250. }
  251.  
  252. /* Copy a monochrome bitmap. */
  253. private int
  254. mem_true24_copy_mono(gx_device *dev,
  255.   const byte *base, int sourcex, int sraster, gx_bitmap_id id,
  256.   int x, int y, int w, int h, gx_color_index zero, gx_color_index one)
  257. {    const byte *line;
  258.     int sbit;
  259.     int first_bit;
  260.     declare_scan_ptr(dest);
  261.  
  262.     fit_copy(dev, base, sourcex, sraster, id, x, y, w, h);
  263.     setup_rect(dest);
  264.     line = base + (sourcex >> 3);
  265.     sbit = sourcex & 7;
  266.     first_bit = 0x80 >> sbit;
  267.     if ( zero != gx_no_color_index )
  268.       {    /* Loop for halftones or inverted masks */
  269.         /* (never used). */
  270.         declare_unpack_color(r0, g0, b0, zero);
  271.         declare_unpack_color(r1, g1, b1, one);
  272.         while ( h-- > 0 )
  273.            {    register byte *pptr = dest;
  274.             const byte *sptr = line;
  275.             register int sbyte = *sptr++;
  276.             register int bit = first_bit;
  277.             int count = w;
  278.             do
  279.               {    if ( sbyte & bit )
  280.                   { if ( one != gx_no_color_index )
  281.                       put3(pptr, r1, g1, b1);
  282.                   }
  283.                 else
  284.                   put3(pptr, r0, g0, b0);
  285.                 pptr += 3;
  286.                 if ( (bit >>= 1) == 0 )
  287.                   bit = 0x80, sbyte = *sptr++;
  288.               }
  289.             while ( --count > 0 );
  290.             line += sraster;
  291.             inc_ptr(dest, draster);
  292.            }
  293.       }
  294.     else if ( one != gx_no_color_index )
  295.       {    /* Loop for character and pattern masks. */
  296.         /* This is used heavily. */
  297.         declare_unpack_color(r1, g1, b1, one);
  298.         int first_mask = first_bit << 1;
  299.         int first_count, first_skip;
  300.         if ( sbit + w > 8 )
  301.           first_mask -= 1,
  302.           first_count = 8 - sbit;
  303.         else
  304.           first_mask -= first_mask >> w,
  305.           first_count = w;
  306.         first_skip = first_count * 3;
  307.         while ( h-- > 0 )
  308.            {    register byte *pptr = dest;
  309.             const byte *sptr = line;
  310.             register int sbyte = *sptr++ & first_mask;
  311.             int count = w - first_count;
  312.             if ( sbyte )
  313.               {    register int bit = first_bit;
  314.                 do
  315.                   {    if ( sbyte & bit )
  316.                       put3(pptr, r1, g1, b1);
  317.                     pptr += 3;
  318.                   }
  319.                 while ( (bit >>= 1) & first_mask );
  320.               }
  321.             else
  322.               pptr += first_skip;
  323.             while ( count >= 8 )
  324.               {    sbyte = *sptr++;
  325.                 if ( sbyte & 0xf0 )
  326.                   { if ( sbyte & 0x80 )
  327.                       put3(pptr, r1, g1, b1);
  328.                     if ( sbyte & 0x40 )
  329.                       put3(pptr + 3, r1, g1, b1);
  330.                     if ( sbyte & 0x20 )
  331.                       put3(pptr + 6, r1, g1, b1);
  332.                     if ( sbyte & 0x10 )
  333.                       put3(pptr + 9, r1, g1, b1);
  334.                   }
  335.                 if ( sbyte & 0xf )
  336.                   { if ( sbyte & 8 )
  337.                       put3(pptr + 12, r1, g1, b1);
  338.                     if ( sbyte & 4 )
  339.                       put3(pptr + 15, r1, g1, b1);
  340.                     if ( sbyte & 2 )
  341.                       put3(pptr + 18, r1, g1, b1);
  342.                     if ( sbyte & 1 )
  343.                       put3(pptr + 21, r1, g1, b1);
  344.                   }
  345.                 pptr += 24;
  346.                 count -= 8;
  347.               }
  348.             if ( count > 0 )
  349.               {    register int bit = 0x80;
  350.                 sbyte = *sptr++;
  351.                 do
  352.                   {    if ( sbyte & bit )
  353.                       put3(pptr, r1, g1, b1);
  354.                     pptr += 3;
  355.                     bit >>= 1;
  356.                   }
  357.                 while ( --count > 0 );
  358.               }
  359.             line += sraster;
  360.             inc_ptr(dest, draster);
  361.            }
  362.       }
  363.     return 0;
  364. }
  365.  
  366. /* Copy a color bitmap. */
  367. private int
  368. mem_true24_copy_color(gx_device *dev,
  369.   const byte *base, int sourcex, int sraster, gx_bitmap_id id,
  370.   int x, int y, int w, int h)
  371. {    fit_copy(dev, base, sourcex, sraster, id, x, y, w, h);
  372.     mem_copy_byte_rect(mdev, base, sourcex, sraster, x, y, w, h);
  373.     return 0;
  374. }
  375.  
  376. /* Copy an alpha map. */
  377. private int
  378. mem_true24_copy_alpha(gx_device *dev, const byte *base, int sourcex,
  379.   int sraster, gx_bitmap_id id, int x, int y, int w, int h,
  380.   gx_color_index color, int depth)
  381. {    const byte *line;
  382.     declare_scan_ptr(dest);
  383.     declare_unpack_color(r, g, b, color);
  384.  
  385.     fit_copy(dev, base, sourcex, sraster, id, x, y, w, h);
  386.     setup_rect(dest);
  387.     line = base;
  388.     while ( h-- > 0 )
  389.       {    register byte *pptr = dest;
  390.         int sx;
  391.  
  392.         for ( sx = sourcex; sx < sourcex + w; ++sx, pptr += 3 )
  393.           { int alpha2, alpha;
  394.  
  395.             if ( depth == 2 )    /* map 0 - 3 to 0 - 15 */
  396.               alpha =
  397.             ((line[sx >> 2] >> ((3 - (sx & 3)) << 1)) & 3) * 5;
  398.             else 
  399.               alpha2 = line[sx >> 1],
  400.               alpha = (sx & 1 ? alpha2 & 0xf : alpha2 >> 4);
  401.             if ( alpha == 15 )
  402.               { /* Just write the new color. */
  403.             put3(pptr, r, g, b);
  404.               }
  405.             else if ( alpha != 0 )
  406.               { /* Blend RGB values. */
  407. #define make_shade(old, clr, alpha, amax) \
  408.   (old) + (((int)(clr) - (int)(old)) * (alpha) / (amax))
  409.             pptr[0] = make_shade(pptr[0], r, alpha, 15);
  410.             pptr[1] = make_shade(pptr[1], g, alpha, 15);
  411.             pptr[2] = make_shade(pptr[2], b, alpha, 15);
  412. #undef make_shade
  413.               }
  414.           }
  415.         line += sraster;
  416.         inc_ptr(dest, draster);
  417.        }
  418.     return 0;
  419. }
  420.  
  421. /* ================ "Word"-oriented device ================ */
  422.  
  423. /* Note that on a big-endian machine, this is the same as the */
  424. /* standard byte-oriented-device. */
  425.  
  426. #if !arch_is_big_endian
  427.  
  428. /* Procedures */
  429. declare_mem_procs(mem24_word_copy_mono, mem24_word_copy_color, mem24_word_fill_rectangle);
  430.  
  431. /* Here is the device descriptor. */
  432. const gx_device_memory far_data mem_true24_word_device =
  433.   mem_full_device("image24w", 24, 0, mem_open,
  434.     gx_default_rgb_map_rgb_color, gx_default_rgb_map_color_rgb,
  435.     mem24_word_copy_mono, mem24_word_copy_color, mem24_word_fill_rectangle,
  436.     mem_word_get_bits, gx_default_map_cmyk_color,
  437.     gx_default_strip_tile_rectangle, gx_no_strip_copy_rop);
  438.  
  439. /* Fill a rectangle with a color. */
  440. private int
  441. mem24_word_fill_rectangle(gx_device *dev, int x, int y, int w, int h,
  442.   gx_color_index color)
  443. {    byte *base;
  444.     uint raster;
  445.     fit_fill(dev, x, y, w, h);
  446.     base = scan_line_base(mdev, y);
  447.     raster = mdev->raster;
  448.     mem_swap_byte_rect(base, raster, x * 24, w * 24, h, true);
  449.     mem_true24_fill_rectangle(dev, x, y, w, h, color);
  450.     mem_swap_byte_rect(base, raster, x * 24, w * 24, h, false);
  451.     return 0;
  452. }
  453.  
  454. /* Copy a bitmap. */
  455. private int
  456. mem24_word_copy_mono(gx_device *dev,
  457.   const byte *base, int sourcex, int sraster, gx_bitmap_id id,
  458.   int x, int y, int w, int h, gx_color_index zero, gx_color_index one)
  459. {    byte *row;
  460.     uint raster;
  461.     bool store;
  462.     fit_copy(dev, base, sourcex, sraster, id, x, y, w, h);
  463.     row = scan_line_base(mdev, y);
  464.     raster = mdev->raster;
  465.     store = (zero != gx_no_color_index && one != gx_no_color_index);
  466.     mem_swap_byte_rect(row, raster, x * 24, w * 24, h, store);
  467.     mem_true24_copy_mono(dev, base, sourcex, sraster, id,
  468.                  x, y, w, h, zero, one);
  469.     mem_swap_byte_rect(row, raster, x * 24, w * 24, h, false);
  470.     return 0;
  471. }
  472.  
  473. /* Copy a color bitmap. */
  474. private int
  475. mem24_word_copy_color(gx_device *dev,
  476.   const byte *base, int sourcex, int sraster, gx_bitmap_id id,
  477.   int x, int y, int w, int h)
  478. {    byte *row;
  479.     uint raster;
  480.     fit_copy(dev, base, sourcex, sraster, id, x, y, w, h);
  481.     row = scan_line_base(mdev, y);
  482.     raster = mdev->raster;
  483.     mem_swap_byte_rect(row, raster, x * 24, w * 24, h, true);
  484.     bytes_copy_rectangle(row + x * 3, raster, base + sourcex * 3, sraster,
  485.                  w * 3, h);
  486.     mem_swap_byte_rect(row, raster, x * 24, w * 24, h, false);
  487.     return 0;
  488. }
  489.  
  490. #endif                /* !arch_is_big_endian */
  491.